/*****************************************************************************/
/*                        >>> func_strings.c <<<                             */
/*	Trabajo Practico 2do. cuatrimestre 2011                                  */
/*	TP:"FUSELAJE"                                                            */
/*	GRUPO: Reduce Fat Fast                                                   */
/*	INTEGRANTES: Emanuel Genovese                                            */
/*               Federico Gabriel Garcia                                     */
/*               Federico Pioli                                              */
/*               Esther Insfrain                                             */
/*               Luciano Bagattin                                            */
/*	Fecha UM:                                                                */
/*****************************************************************************/

/*****************************************************************************/
/*		        	Include					                                 */
/*****************************************************************************/
#include "func_strings.h"
#include <string.h>
#include <math.h>
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>

/******************************************************************************/
/* Nombre de Procedimiento: pIntacad                                          */
/* Parametros: iNum: Numero a convertir                                       */
/*             cCadenaResultado: Cadena convertida                            */
/*	                                                                          */
/* Descripcion: Procedimiento que se encarga de convertir un numero en una    */
/*              cadena.                                                       */
/******************************************************************************/

void pIntacad(int iNum, char* cCadenaResultado) {
	/*declaracion de variables locales*/
	int j = 0;
	int i = 0;
	char aux = '\0'; //K
	/*fin de la declaracion de variables locales*/

	do {
		cCadenaResultado[i] = (iNum % 10) + '0';
		iNum = iNum / 10;
		i++;
	} while (iNum > 0);

	cCadenaResultado[i] = '\0';
	i--;

	while (i > j) {
		aux = cCadenaResultado[i];
		cCadenaResultado[i] = cCadenaResultado[j];
		cCadenaResultado[j] = aux;
		i--;
		j++;
	}

} //fin del pIntaCad

/******************************************************************************/
/* Nombre de Procedimiento: pCadaInt                                          */
/* Parametros: cCadena: Cadena a convertir a numero                           */
/*             iResultado: numero convertido                                  */
/*	                                                                          */
/* Descripcion: Procedimiento que se encarga de convertir una cadena a        */
/*              numero.                                                       */
/******************************************************************************/

void pCadaInt(char * cCadena, int * iResultado) {
	/*declaracion de variables locales*/

	/*fin declaracion de variables locales*/
	int j = 0;
	int i = strlen(cCadena);
	int aux = 0;
	int a = 0;
	for (; i > 0; i--) {
		aux = cCadena[i - 1] - '0';
		a += aux * ((int) pow(10, j));
		j++;
	}
	*iResultado = a;

} //fin del pCadaInt

/******************************************************************************/
/* Nombre de Procedimiento: pSepaVar                                          */
/* Parametros: Instruccion: Cadena que se tiene la instruccion que envia      */
/*                            el KSS                                          */
/* Descripcion: Procedimiento que se encarga de pasar a 2 variables           */
/*              los cilindros que quiero obtener                              */
/******************************************************************************/
void pSepaVar(char* Instruccion, char* var1, char* var2) {
	int i = 0;
	int j = 0;
	while (Instruccion[i] != ',')
		var1[j++] = Instruccion[i++];
	var1[j] = '\0';
	j = 0;
	++i;
	while (Instruccion[i] != '\0')
		var2[j++] = Instruccion[i++];
} //fin del pSepaVar

/******************************************************************************/
/* Nombre de Procedimiento: fValidarCadena                                    */
/* Parametros: Instruccion: Cadena que se tiene la instruccion que envia      */
/*                            el KSS                                          */
/* Descripcion: Funcion que valida la lista de sectores que se van a leeer    */
/******************************************************************************/

int fValidarCadena(char * cadena) {
	/*declaracion de variables locales*/
	char cComienzo = cadena[0];
	char cFinal = cadena[((int) strlen(cadena)) - 1];
	char sResto[1000] = "\0";
	char sNumero[50] = "\0";
	int iCantidadSectores = 0;
	int i = 0, a, j = 0;
	/*fin de la declaracion de variables locales*/

	sResto[strlen(sResto)] = '\0';
	if ((cComienzo == '(') && (cFinal == ')')) {
		//pSepaStruct(sResto, cadena);

		for (; cadena[i] != '('; i++)
			;
		for (i++; cadena[i] != ')'; sResto[j] = cadena[i], i++, j++)
			;
		sResto[i] = '\0';
		i = 0;
		while (sResto[i] != '\0') {
			for (a = 0; sResto[i] != ',' && sResto[i] != '\0'; i++, a++) {
				sNumero[a] = sResto[i];
			} //fin del for

			if (strcmp(fValida_numero(sNumero), "-1") == 0) {
				/*Verifico si el numero es valido si es devuelvo 1 caso contrario 1*/
				return 1;
			} else {
				iCantidadSectores++;
				memset(sNumero, 0, sizeof(sNumero));
			}
			i++;

		} //fin del while.
		if (iCantidadSectores <= 5) {
			return 0;
		} else {
			return 2;
		} //fin del if
	} //fin del if
	return 1;
} //fin del fValidarCadena

/****************************************************************************/
/* Nombre de funcion: fValida_numero                                        */
/* Parametros:   s: cadena en la cual si es positivo o si tiene caracteres  */
/*                  numericos                                               */
/* Descripcion: Recorre toda la cadena con el objetivo de verificar si      */
/*                algun elemento es negativo o posee letras                 */
/****************************************************************************/

char * fValida_numero(char * cad) {
	int i, tam, sw, num;

	i = 0;
	sw = 0;

	tam = (int) strlen(cad);
	if (tam < 1 || tam > 5) {
		printf("\nERROR EN EL TAMANIO DEL NUMERO!!!!!\n");
		return "-1";
	}

	num = atoi(&*cad);
	if (num < 0 || num > 65535) {
		printf("\nERROR DE DESBORDAMIENTO!!!!!\n");
		return "-1";
	}

	while (i < tam && sw == 0) {
		if (isdigit ( cad[i] ) == 0) {
			printf("\nERROR CONTIENE CARACTERES NO NUMERICOS!!!!!\n");
			sw = 1;
		}
		i = i + 1;
	}
	if (sw == 1) {
		return "-1";
	}

	return cad;
}

/********************************************************************************/
/* Nombre de Procedimiento: pSepaStruct                                         */
/* Parametros: Instruccion: Cadena con el contenido de los sectores que va a    */
/*                            transformar                                       */
/*               Struct:Cadena transformada sin los parentesis.                 */
/* Descripcion: Procedimiento que se encarga de formatear la cadena de sectores */
/********************************************************************************/

void pSepaStruct(char* Instruccion,char* Struct)
{
        int i=0,j=0;

        for(;Instruccion[i]!='(';i++);
        for(i++;Instruccion[i]!=')';Struct[j]=Instruccion[i],i++,j++);
        Struct[i]='\0';
}//fin del pSepaStruct

/****************************************************************************/
/* Nombre de funcion: pConvierteSectores                                    */
/* Parametros:   sectores: cadena de sectores                               */
/*               vector de entero de 5 posicion                             */
/* Descripcion: Recorre toda la cadena con el objetivo de verificar si      */
/*                algun elemento es negativo o posee letras                 */
/****************************************************************************/
void pConvierteSectores(char *sSectores, int vVSect[], int *iCant) {
	int iSector, a, i, j = 0;
	char Instruccion[150];
	char Numero[10];

    pSepaStruct(sSectores, Instruccion);
	for (i = 0; Instruccion[i] != '\0';) {
		memset(Numero, '\0', 10);
		for (a = 0; Instruccion[i] != ',' && Instruccion[i] != '\0'; i++, a++) {
			Numero[a] = Instruccion[i];
		} //fin del for

		Numero[a] = '\0';
		pCadaInt(Numero, &iSector);
		vVSect[j] = iSector;
		j++;

	} //fin del for
	iCant = &j;

} //fin del pConvierteSectores

